package club.service.impl;

import club.dao.CommentMapper;
import club.pojo.Answer;
import club.dao.PetMapper;
import club.dao.UserMapper;
import club.pojo.Comment;
import club.pojo.Pet;
import club.pojo.User;
import club.service.AnswerService;
import club.pojo.Pet;
import club.pojo.User;
import club.dao.AdminMapper;
import club.pojo.*;
import club.service.CommentService;
import club.service.PetService;
import club.service.UserService;
import club.service.UserService;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
@Transactional
public class CommentServiceImpl implements CommentService {

    @Resource
    private CommentMapper commentMapper; // 注入评论Mapper

    @Resource
    private UserMapper userMapper; // 注入用户Mapper

    @Resource
    private PetMapper petMapper; // 注入宠物Mapper

    @Resource
    private AdminMapper adminMapper; // 注入管理员Mapper

    @Resource
    private UserService userService; // 注入用户服务

    @Resource
    private PetService petService; // 注入宠物服务

    @Resource
    private AnswerService answerService; // 注入回答服务

    /**
     * 查询所有评论信息（分页），可以根据用户名筛选
     * @param userName 用户名，用于筛选评论的用户
     * @param pn 当前页码
     * @param pageSize 每页显示条数
     * @return 分页后的评论信息列表
     */
    @Override
    public PageInfo<Comment> allComment(String userName, Integer pn, Integer pageSize) {
        // 根据用户名查询用户信息列表
        List<User> users = userService.showName(userName);
        // 提取用户ID列表
        List<Integer> userIds = new ArrayList<>();
        for (User user : users){
            userIds.add(user.getId());
        }
        // 使用PageHelper进行分页设置
        PageHelper.startPage(pn, pageSize);
        // 构建查询条件
        EntityWrapper wrapper = new EntityWrapper();
        if (users != null){
            wrapper.in("userId", userIds);
        }
        // 查询符合条件的评论列表
        List<Comment> list = commentMapper.selectList(wrapper);
        // 遍历评论列表，设置评论的用户信息和宠物信息
        for (Comment comment : list) {
            User u = userMapper.selectById(comment.getUserId());
            comment.setUser(u);
            Pet pet = petMapper.selectById(comment.getPetId());
            comment.setPet(pet);
        }
        // 封装为分页对象
        PageInfo<Comment> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    /**
     * 查询指定宠物的所有评论
     * @param petId 宠物ID
     * @return 指定宠物的评论列表
     */
    @Override
    public List<Comment> petComments(Integer petId) {
        // 构建查询条件
        EntityWrapper wrapper = new EntityWrapper();
        if (petId != null) {
            wrapper.eq("petId", petId);
        }
        // 查询指定宠物的评论列表
        List<Comment> comments = commentMapper.selectList(wrapper);
        // 遍历评论列表，设置评论的用户信息、宠物信息和关联的回答信息
        for (Comment comment : comments){
            User user = userService.findById(comment.getUserId());
            comment.setUser(user);
            Pet pet = petService.findById(comment.getPetId());
            comment.setPet(pet);
            List<Answer> answers = answerService.answersAboutOneComment(comment.getId());
            comment.setAnswer(answers);
        }
        return comments;
    }

    /**
     * 创建新的评论
     * @param userId 用户ID
     * @param petId 宠物ID
     * @param content 评论内容
     * @return 插入操作影响的行数，通常为1
     */
    @Override
    public Integer create(Integer userId, Integer petId, String content) {
        // 创建评论对象
        Comment comment = new Comment();
        comment.setUserId(userId);
        comment.setPetId(petId);
        comment.setCommentTime(new Date());
        comment.setContent(content);
        // 执行插入操作
        return commentMapper.insert(comment);
    }

    /**
     * 根据评论ID查询评论信息
     * @param id 评论ID
     * @return 对应ID的评论信息，若不存在则返回null
     */
    @Override
    public Comment findById(Integer id) {
        // 根据ID查询评论信息
        return commentMapper.selectById(id);
    }

    /**
     * 查询所有评论信息（分页），可以根据用户名模糊查询
     * @param userName 用户名，用于模糊查询评论的用户名
     * @param pageNum 当前页码
     * @param pageSize 每页显示条数
     * @return 分页后的评论信息列表
     */
    @Override
    public PageInfo<Comment> all(String userName, Integer pageNum, Integer pageSize) {
        // 使用PageHelper进行分页设置
        PageHelper.startPage(pageNum, pageSize);
        // 构建查询条件
        EntityWrapper<Comment> wrapper = new EntityWrapper<>();
        if (userName != null && !"".equals(userName)) {
            wrapper.like("userName", userName);
        }
        // 查询符合条件的评论列表
        List<Comment> list = commentMapper.selectList(wrapper);
        // 遍历评论列表，设置评论的宠物信息、用户信息和管理员信息
        for (Comment comment : list) {
            Pet pet = petMapper.selectById(comment.getPetId());
            comment.setPet(pet);
            User user = userMapper.selectById(comment.getUserId());
            comment.setUser(user);
            Admins admins = adminMapper.selectById(comment.getAdminsId());
            comment.setAdmin(admins);
        }
        // 封装为分页对象
        PageInfo<Comment> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    /**
     * 更新评论信息
     * @param comment 待更新的评论对象
     * @return 更新操作影响的行数，通常为1
     */
    @Override
    public int update(Comment comment) {
        // 执行更新操作
        return commentMapper.updateById(comment);
    }

    /**
     * 删除评论信息
     * @param id 待删除评论的ID
     * @return 删除操作影响的行数，通常为1
     */
    @Override
    public int delete(Integer id) {
        // 执行删除操作
        return commentMapper.deleteById(id);
    }
}